home *** CD-ROM | disk | FTP | other *** search
/ The Arsenal Files 8 / The Arsenal Files Collection #8 (Arsenal Computer) (1996).ISO / prg_casm / vidmgr13.zip / VMGRDOS.C < prev    next >
C/C++ Source or Header  |  1996-10-03  |  11KB  |  545 lines
  1. /*
  2.  *  VMGRDOS.C  VidMgr module for MS-DOS compilers.  Release 1.3.
  3.  *
  4.  *  This module written in March 1996 by Andrew Clarke and released to the
  5.  *  public domain.  Last modified in October 1996.
  6.  */
  7.  
  8. #include <string.h>
  9. #include <dos.h>
  10. #include "vidmgr.h"
  11. #include "opsys.h"
  12.  
  13. #if defined(__POWERC) || (defined(__TURBOC__) && !defined(__BORLANDC__)) || \
  14.   (defined(__ZTC__) && !defined(__SC__))
  15. #define FAR far
  16. #else
  17. #if defined(__MSDOS__) || defined(MSDOS) || defined(DOS)
  18. #define FAR _far
  19. #else
  20. #define FAR
  21. #endif
  22. #endif
  23.  
  24. #ifndef MK_FP
  25. #define MK_FP(seg,off) \
  26.   ((void FAR *)(((unsigned long)(seg) << 16)|(unsigned)(off)))
  27. #endif
  28.  
  29. static int vm_iscolorcard(void);
  30. static char vm_getscreenmode(void);
  31. static void vm_setscreenmode(char mode);
  32. static void vm_setcursorsize(char start, char end);
  33. static void vm_getcursorsize(char *start, char *end);
  34. static void vm_getkey(unsigned char *chScan, unsigned char *chChar);
  35.  
  36. void vm_init(void)
  37. {
  38.     vm_getinfo(&vm_startup);
  39.     vm_setattr(vm_startup.attr);
  40.     opsysDetect();
  41. }
  42.  
  43. void vm_done(void)
  44. {
  45.     if (vm_getscreenmode() != vm_startup.mode)
  46.     {
  47.         vm_setscreenmode(vm_startup.mode);
  48.     }
  49.     vm_setcursorsize(vm_startup.cur_start, vm_startup.cur_end);
  50. }
  51.  
  52. void vm_getinfo(struct vm_info *v)
  53. {
  54.     v->ypos = vm_wherey();
  55.     v->xpos = vm_wherex();
  56.     v->attr = vm_getattrxy(v->xpos, v->ypos);
  57.     v->mode = vm_getscreenmode();
  58.     v->height = vm_getscreenheight();
  59.     v->width = vm_getscreenwidth();
  60.     vm_getcursorsize(&v->cur_start, &v->cur_end);
  61. }
  62.  
  63. static int vm_iscolorcard(void)
  64. {
  65.     return vm_getscreenmode() != 7;
  66. }
  67.  
  68. #if defined(__WATCOMC__) && defined(__386__)
  69.  
  70. char *vm_screenptr(char x, char y)
  71. {
  72.     char *ptr;
  73.     if (vm_iscolorcard())
  74.     {
  75.         ptr = (char *)(opsysGetVideoSeg(0xB800) << 4);
  76.     }
  77.     else
  78.     {
  79.         ptr = (char *)(opsysGetVideoSeg(0xB000) << 4);
  80.     }
  81.     return ptr + (y * vm_getscreenwidth() * 2) + (x * 2);
  82. }
  83.  
  84. #else
  85.  
  86. char FAR *vm_screenptr(char x, char y)
  87. {
  88.     char FAR *ptr;
  89.     if (vm_iscolorcard())
  90.     {
  91.         ptr = (char FAR *)MK_FP(opsysGetVideoSeg(0xB800), 0x0000);
  92.     }
  93.     else
  94.     {
  95.         ptr = (char FAR *)MK_FP(opsysGetVideoSeg(0xB000), 0x0000);
  96.     }
  97.     return ptr + (y * vm_getscreenwidth() * 2) + (x * 2);
  98. }
  99.  
  100. #endif
  101.  
  102. static char vm_getscreenmode(void)
  103. {
  104. #if defined(__WATCOMC__) && defined(__386__)
  105.     return *((char *)0x0449);
  106. #else
  107.     return *((char FAR *)MK_FP(0x0040, 0x0049));
  108. #endif
  109. }
  110.  
  111. static void vm_setscreenmode(char mode)
  112. {
  113. #if defined(__TURBOC__)
  114.     _AH = 0x00;
  115.     _AL = mode;
  116.     geninterrupt(0x10);
  117. #else
  118.     union REGS regs;
  119.     regs.h.ah = 0x00;
  120.     regs.h.al = mode;
  121. #if defined(__WATCOMC__) && defined(__386__)
  122.     int386(0x10, ®s, ®s);
  123. #else
  124.     int86(0x10, ®s, ®s);
  125. #endif
  126. #endif
  127. }
  128.  
  129. char vm_getscreenwidth(void)
  130. {
  131. #if defined(__WATCOMC__) && defined(__386__)
  132.     return *((char *)0x044a);
  133. #else
  134.     return *((char FAR *)MK_FP(0x0040, 0x004a));
  135. #endif
  136. }
  137.  
  138. char vm_getscreenheight(void)
  139. {
  140. #if defined(__WATCOMC__) && defined(__386__)
  141.     return (char)(*((char *)0x0484) + 1);
  142. #else
  143.     return (char)(*((char FAR *)MK_FP(0x0040, 0x0084)) + 1);
  144. #endif
  145. }
  146.  
  147. short vm_getscreensize(void)
  148. {
  149. #if defined(__WATCOMC__) && defined(__386__)
  150.     return *((short *)0x044c);
  151. #else
  152.     return *((short FAR *)MK_FP(0x0040, 0x004c));
  153. #endif
  154. }
  155.  
  156. void vm_gotoxy(char x, char y)
  157. {
  158. #if defined(__TURBOC__)
  159.     _AH = 0x02;
  160.     _BH = 0;
  161.     _DH = y - 1;
  162.     _DL = x - 1;
  163.     geninterrupt(0x10);
  164. #else
  165.     union REGS regs;
  166.     regs.h.ah = 0x02;
  167.     regs.h.bh = 0;
  168.     regs.h.dh = (unsigned char)(y - 1);
  169.     regs.h.dl = (unsigned char)(x - 1);
  170. #if defined(__WATCOMC__) && defined(__386__)
  171.     int386(0x10, ®s, ®s);
  172. #else
  173.     int86(0x10, ®s, ®s);
  174. #endif
  175. #endif
  176. }
  177.  
  178. char vm_wherex(void)
  179. {
  180. #if defined(__WATCOMC__) && defined(__386__)
  181.     return (char)(*((char *)0x0450) + 1);
  182. #else
  183.     return (char)(*((char FAR *)MK_FP(0x0040, 0x0050)) + 1);
  184. #endif
  185. }
  186.  
  187. char vm_wherey(void)
  188. {
  189. #if defined(__WATCOMC__) && defined(__386__)
  190.     return (char)(*((char *)0x0451) + 1);
  191. #else
  192.     return (char)(*((char FAR *)MK_FP(0x0040, 0x0051)) + 1);
  193. #endif
  194. }
  195.  
  196. static void vm_setcursorsize(char start, char end)
  197. {
  198. #if defined(__TURBOC__)
  199.     _AH = 0x01;
  200.     _CH = start;
  201.     _CL = end;
  202.     geninterrupt(0x10);
  203. #else
  204.     union REGS regs;
  205.     regs.h.ah = 0x01;
  206.     regs.h.ch = start;
  207.     regs.h.cl = end;
  208. #if defined(__WATCOMC__) && defined(__386__)
  209.     int386(0x10, ®s, ®s);
  210. #else
  211.     int86(0x10, ®s, ®s);
  212. #endif
  213. #endif
  214. }
  215.  
  216. static void vm_getcursorsize(char *start, char *end)
  217. {
  218. #if defined(__TURBOC__)
  219.     _AH = 0x03;
  220.     _BH = 0;
  221.     geninterrupt(0x10);
  222.     *start = _CH;
  223.     *end = _CL;
  224. #else
  225.     union REGS regs;
  226.     regs.h.ah = 0x03;
  227.     regs.h.bh = 0;
  228. #if defined(__WATCOMC__) && defined(__386__)
  229.     int386(0x10, ®s, ®s);
  230. #else
  231.     int86(0x10, ®s, ®s);
  232. #endif
  233.     *start = regs.h.ch;
  234.     *end = regs.h.cl;
  235. #endif
  236. }
  237.  
  238. int vm_kbhit(void)
  239. {
  240.     static unsigned short counter = 0;
  241.     if (counter % 10 == 0)
  242.     {
  243.         opsysTimeSlice();
  244.     }
  245.     counter++;
  246. #if defined(_MSC_VER) || defined(_QC) || defined(__SC__)
  247.     _asm
  248.     {
  249.         mov    ah,0x01
  250.         int    16h
  251.         jz     nokey
  252.     }
  253.     return 1;
  254. nokey:
  255.     return 0;
  256. #elif defined(__TURBOC__)
  257.     _AH = 0x01;
  258.     geninterrupt(0x16);
  259.     return !(_FLAGS & 0x40);
  260. #else
  261.     {
  262.         union REGPACK regpack;
  263.         memset(®pack, 0, sizeof regpack);
  264.         regpack.h.ah = 0x01;
  265.         intr(0x16, ®pack);
  266.         return !(regpack.x.flags & 0x40);
  267.     }
  268. #endif
  269. }
  270.  
  271. static void vm_getkey(unsigned char *chScan, unsigned char *chChar)
  272. {
  273. #if defined(__TURBOC__)
  274.     _AH = 0x00;
  275.     geninterrupt(0x16);
  276.     *chScan = _AH;
  277.     *chChar = _AL;
  278. #else
  279.     union REGS regs;
  280.     regs.h.ah = 0x00;
  281. #if defined(__WATCOMC__) && defined(__386__)
  282.     int386(0x16, ®s, ®s);
  283. #else
  284.     int86(0x16, ®s, ®s);
  285. #endif
  286.     *chScan = regs.h.ah;
  287.     *chChar = regs.h.al;
  288. #endif
  289. }
  290.  
  291. int vm_getch(void)
  292. {
  293.     unsigned char chChar, chScan;
  294.  
  295.     while (!vm_kbhit())
  296.     {
  297.         /* nada */
  298.     }
  299.  
  300.     vm_getkey(&chScan, &chChar);
  301.     if (chChar == 0xe0)
  302.     {
  303.         if (chScan)
  304.         {
  305.             chChar = 0;         /* force scan return */
  306.         }
  307.         else
  308.         {                       /* get next block */
  309.             chChar = 0;
  310.  
  311.             vm_getkey(&chScan, &chChar);
  312.             if (!chScan)
  313.             {                   /* still no scan? */
  314.                 chScan = chChar;  /* move new char over */
  315.                 chChar = 0;     /* force its return */
  316.             }
  317.             else
  318.             {
  319.                 chChar = 0;     /* force new scan */
  320.             }
  321.         }
  322.     }
  323.     if (chScan == 0xe0)
  324.     {
  325.         if (!chChar)
  326.         {
  327.             chScan = 0;
  328.  
  329.             vm_getkey(&chScan, &chChar);
  330.             if (!chScan)
  331.             {                   /* still no scan? */
  332.                 chScan = chChar;  /* move new char over */
  333.                 chChar = 0;     /* force its return */
  334.             }
  335.             else
  336.             {
  337.                 chChar = 0;     /* force new scan */
  338.             }
  339.         }
  340.         else
  341.         {
  342.             chScan = 0;         /* handle 0xe00d case */
  343.         }
  344.     }
  345.     if (chChar)
  346.     {
  347.         chScan = 0;
  348.     }
  349.  
  350.     return (int)((chScan << 8) + (chChar));
  351. }
  352.  
  353. void vm_setcursorstyle(int style)
  354. {
  355.     if (vm_iscolorcard())
  356.     {
  357.         switch (style)
  358.         {
  359.         case CURSORHALF:
  360.             vm_setcursorsize(4, 7);
  361.             break;
  362.         case CURSORFULL:
  363.             vm_setcursorsize(0, 7);
  364.             break;
  365.         case CURSORNORM:
  366.             vm_setcursorsize(7, 8);
  367.             break;
  368.         case CURSORHIDE:
  369.             vm_setcursorsize(32, 32);
  370.             break;
  371.         default:
  372.             break;
  373.         }
  374.     }
  375.     else
  376.     {
  377.         switch (style)
  378.         {
  379.         case CURSORHALF:
  380.             vm_setcursorsize(8, 13);
  381.             break;
  382.         case CURSORFULL:
  383.             vm_setcursorsize(0, 13);
  384.             break;
  385.         case CURSORNORM:
  386.             vm_setcursorsize(11, 13);
  387.             break;
  388.         case CURSORHIDE:
  389.             vm_setcursorsize(32, 32);
  390.             break;
  391.         default:
  392.             break;
  393.         }
  394.     }
  395. }
  396.  
  397. char vm_getchxy(char x, char y)
  398. {
  399.     char FAR *p;
  400.     p = vm_screenptr((char)(x - 1), (char)(y - 1));
  401.     return *p;
  402. }
  403.  
  404. char vm_getattrxy(char x, char y)
  405. {
  406.     char FAR *p;
  407.     p = vm_screenptr((char)(x - 1), (char)(y - 1));
  408.     return *(p + 1);
  409. }
  410.  
  411. void vm_xgetchxy(char x, char y, char *attr, char *ch)
  412. {
  413.     char FAR *p;
  414.     p = vm_screenptr((char)(x - 1), (char)(y - 1));
  415.     *ch = *p;
  416.     *attr = *(p + 1);
  417. }
  418.  
  419. void vm_putch(char x, char y, char ch)
  420. {
  421.     char FAR *p;
  422.     p = vm_screenptr((char)(x - 1), (char)(y - 1));
  423.     *p = ch;
  424. }
  425.  
  426. void vm_puts(char x, char y, char *str)
  427. {
  428.     char FAR *p;
  429.     p = vm_screenptr((char)(x - 1), (char)(y - 1));
  430.     while (*str)
  431.     {
  432.         *p++ = *str++;
  433.         p++;
  434.     }
  435. }
  436.  
  437. void vm_xputch(char x, char y, char attr, char ch)
  438. {
  439.     char FAR *p;
  440.     p = vm_screenptr((char)(x - 1), (char)(y - 1));
  441.     *p = ch;
  442.     *(p + 1) = attr;
  443. }
  444.  
  445. void vm_xputs(char x, char y, char attr, char *str)
  446. {
  447.     char FAR *p;
  448.     p = vm_screenptr((char)(x - 1), (char)(y - 1));
  449.     while (*str)
  450.     {
  451.         *p++ = *str++;
  452.         *p++ = attr;
  453.     }
  454. }
  455.  
  456. void vm_putattr(char x, char y, char attr)
  457. {
  458.     char FAR *p;
  459.     p = vm_screenptr((char)(x - 1), (char)(y - 1));
  460.     *(p + 1) = attr;
  461. }
  462.  
  463. void vm_paintclearbox(char x1, char y1, char x2, char y2, char attr)
  464. {
  465.     char x, y;
  466.     for (y = y1; y <= y2; y++)
  467.     {
  468.         for (x = x1; x <= x2; x++)
  469.         {
  470.             vm_xputch(x, y, attr, ' ');
  471.         }
  472.     }
  473. }
  474.  
  475. void vm_paintbox(char x1, char y1, char x2, char y2, char attr)
  476. {
  477.     char x, y;
  478.     for (y = y1; y <= y2; y++)
  479.     {
  480.         for (x = x1; x <= x2; x++)
  481.         {
  482.             vm_putattr(x, y, attr);
  483.         }
  484.     }
  485. }
  486.  
  487. void vm_clearbox(char x1, char y1, char x2, char y2)
  488. {
  489.     char x, y;
  490.     for (y = y1; y <= y2; y++)
  491.     {
  492.         for (x = x1; x <= x2; x++)
  493.         {
  494.             vm_putch(x, y, ' ');
  495.         }
  496.     }
  497. }
  498.  
  499. void vm_fillbox(char x1, char y1, char x2, char y2, char ch)
  500. {
  501.     char x, y;
  502.     for (y = y1; y <= y2; y++)
  503.     {
  504.         for (x = x1; x <= x2; x++)
  505.         {
  506.             vm_putch(x, y, ch);
  507.         }
  508.     }
  509. }
  510.  
  511. void vm_gettext(char x1, char y1, char x2, char y2, char *dest)
  512. {
  513.     char x, y;
  514.     for (y = y1; y <= y2; y++)
  515.     {
  516.         for (x = x1; x <= x2; x++)
  517.         {
  518.             vm_xgetchxy(x, y, dest + 1, dest);
  519.             dest += 2;
  520.         }
  521.     }
  522. }
  523.  
  524. void vm_puttext(char x1, char y1, char x2, char y2, char *srce)
  525. {
  526.     char x, y;
  527.     for (y = y1; y <= y2; y++)
  528.     {
  529.         for (x = x1; x <= x2; x++)
  530.         {
  531.             vm_xputch(x, y, *(srce + 1), *srce);
  532.             srce += 2;
  533.         }
  534.     }
  535. }
  536.  
  537. void vm_horizline(char x1, char x2, char row, char attr, char ch)
  538. {
  539.     char x;
  540.     for (x = x1; x <= x2; x++)
  541.     {
  542.         vm_xputch(x, row, attr, ch);
  543.     }
  544. }
  545.